package com.bms.client.service.impl;

import com.bms.client.mapper.*;
import com.bms.client.pojo.FeiYongGuanLi;
import com.bms.client.pojo.HeZuoJiHuaGuanLi;
import com.bms.client.pojo.HeZuoJiHuaGuanLiGenXing;
import com.bms.client.pojo.HeZuoJiHuaGuanLiZhengJia;
import com.bms.client.service.HeZuoJiHuaGuanLiService;
import com.bms.client.utils.RedisUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 合作计划管理(HeZuoJiHuaGuanLi)表服务实现类
 *
 * @author makejava
 * @since 2021-03-15 20:22:38
 * @version 1.0
 */
@Service("heZuoJiHuaGuanLiService")
public class HeZuoJiHuaGuanLiServiceImpl implements HeZuoJiHuaGuanLiService {
    @Resource
    private HeZuoJiHuaGuanLiMapper heZuoJiHuaGuanLiMapper;
    @Resource
    private FeiYongGuanLiMapper feiYongGuanLiMapper;
    @Resource
    private LaiFangGuanLiMapper laiFangGuanLiMapper;
    @Resource
    private ChuFangGuanLiMapper chuFangGuanLiMapper;
    @Resource
    private KeYanRenYuanMapper keYanRenYuanMapper;
    @Resource
    private RedisUtils redisUtils;
    /**
     * 根据模糊条件查询总个数
     *
     * @return 返回查询到的总个数
     */
	@Override
    public Map<String, Object> chaXunCount(String mingCheng) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.heZuoJiHuaGuanLiMapper.chaXunCount(mingCheng));
        return map;
    }

    /**
     * 查询所有数据
     * @return  返回所有数据
     */
	@Override
    public Map<String, Object> chaXunAll() {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.heZuoJiHuaGuanLiMapper.chaXunAll());
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
	@Override
    public Map<String, Object> chaXunById(Integer id) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        HeZuoJiHuaGuanLi heZuoJiHuaGuanLi = heZuoJiHuaGuanLiMapper.chaXunById(id);
        if(heZuoJiHuaGuanLi!=null){
            heZuoJiHuaGuanLi.setFeiYongGuanLis(feiYongGuanLiMapper.chaXun(id));
        }
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("obj",heZuoJiHuaGuanLi );
        return map;
    }

    /**
     * 查询分页数据
     *
     * @param page 查询起始位置
     * @param mingCheng 查询条数
     * @return 对象列表
     */
	@Override
    public Map<String, Object> chaXunFenYe(int page, String mingCheng) {
    // 获取当前表中的总记录
        int tableCount = this.heZuoJiHuaGuanLiMapper.chaXunCount(mingCheng);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / 10 + 1;
        // 计算每页开始的下标值
        int xiaBiao = (page - 1) * 10;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.heZuoJiHuaGuanLiMapper.chaXunFenYe(xiaBiao, mingCheng));
        return map;
    }

    /**
     * 新增数据
     *
     * @param heZuoJiHuaGuanLiGenXing 实例对象
     * @return 实例对象
     */
	@Override
    public Map<String, Object> xinZeng(HeZuoJiHuaGuanLiZhengJia heZuoJiHuaGuanLiGenXing) {
        HeZuoJiHuaGuanLi heZuoJiHuaGuanLi=new HeZuoJiHuaGuanLi();
        BeanUtils.copyProperties(heZuoJiHuaGuanLiGenXing,heZuoJiHuaGuanLi);
        heZuoJiHuaGuanLi.setZhuangTai("跟进中");
        this.heZuoJiHuaGuanLiMapper.xinZeng(heZuoJiHuaGuanLi);

        redis(heZuoJiHuaGuanLi.getId(),0);

        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "新增成功");
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param heZuoJiHuaGuanLiGenXing 实例对象
     * @return 实例对象
     */
	@Override
    public Map<String, Object> gengXinById(HeZuoJiHuaGuanLiGenXing heZuoJiHuaGuanLiGenXing) {
        Map<String, Object> map = new HashMap<>();
        if(keYanRenYuanMapper.chaXunById(heZuoJiHuaGuanLiGenXing.getGenJinRen())==null){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "更新成功");
            return map;
        }
	    HeZuoJiHuaGuanLi heZuoJiHuaGuanLi=new HeZuoJiHuaGuanLi();
        BeanUtils.copyProperties(heZuoJiHuaGuanLiGenXing,heZuoJiHuaGuanLi);
        this.heZuoJiHuaGuanLiMapper.gengXinById(heZuoJiHuaGuanLi);


        redis(heZuoJiHuaGuanLi.getId(),1);

        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "更新成功");
        return map;
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
	@Override
    public Map<String, Object> shanChuById(int id) {
        Map<String, Object> map = new HashMap<>();
        HeZuoJiHuaGuanLi heZuoJiHuaGuanLi = heZuoJiHuaGuanLiMapper.chaXunById(id);
        if(heZuoJiHuaGuanLi==null){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "请勿重复删除");
            return map;
        }
        List<FeiYongGuanLi> feiYongGuanLis = feiYongGuanLiMapper.chaXun(id);
        if(feiYongGuanLis!=null&&feiYongGuanLis.size()>0){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "无法删除，合作计划关联费用");
            return map;
        }
        if(laiFangGuanLiMapper.chaXunByHeZuoHihuan(String.valueOf(id))!=0){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "无法删除，合作计划关联来访记录");
            return map;
        }
        if(chuFangGuanLiMapper.chaXunByHeZuoHihuan(String.valueOf(id))!=0){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "无法删除，合作计划关联出访记录");
            return map;
        }
        this.heZuoJiHuaGuanLiMapper.shanChuById(String.valueOf(id));

        if(!redisUtils.redisDelete("heZuoJiHuaGuanLi",String.valueOf(id))){
            map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
            map.put("msg", "请勿重复删除");
            return map;
        }

        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "删除成功");
        return map;
    }

    @Override
    public String ChaXunWeiWanChengHeZuoJiHua() {
        StringBuilder s= new StringBuilder();
        for(HeZuoJiHuaGuanLi heZuoJiHuaGuanLi:heZuoJiHuaGuanLiMapper.ChaXunWeiWanChengHeZuoJiHua()){
            s.append(",").append(heZuoJiHuaGuanLi.getId());
        }
        return s.toString().replaceFirst(",","");
    }
    public void redis(int id,int stat){
	    HeZuoJiHuaGuanLi heZuoJiHuaGuanLi=(HeZuoJiHuaGuanLi) chaXunById(id).get("obj");
	    if(heZuoJiHuaGuanLi!=null){
	        Map<String,String> conditionalQueue=new HashMap<>();
	        conditionalQueue.put("heZuoJiHuaMingZi",heZuoJiHuaGuanLi.getHeZuoJiHuaMingZi());
	        conditionalQueue.put("zhuang_tai",heZuoJiHuaGuanLi.getZhuangTai());
	        if(stat==0){
	            redisUtils.redisInsert("heZuoJiHuaGuanLi",conditionalQueue,String.valueOf(id),heZuoJiHuaGuanLi);
            }
	        if(stat==1){
                redisUtils.redisUpData("heZuoJiHuaGuanLi",conditionalQueue,String.valueOf(id),heZuoJiHuaGuanLi);
            }
        }
    }
}